//!数组

//数组和动态数组Vec
//Rust 使用数组存储相同类型的数据集。 [T; N]表示一个拥有 T 类型，N 个元素的数组。数组的大小是固定

#[test]
pub fn array_demo1() {
    //声明数组，必须让编译器知道数组的大小，通过变量来指定数组的大小是不允许的 改为const
    // let N: usize = 20;
    // let arr = [0; N]; //Error: non-constant used with constant
    // print!("{}", arr[10]);

    let mut array: [i32; 3] = [0; 3];

    array[1] = 1;
    array[2] = 2;

    assert_eq!([1, 2], &array[1..]);

    // This loop prints: 0 1 2
    for x in &array {
        println!("{} ", x);
    }

    let arr: [i32; 4] = [1, 2, 3, 4];
    for x in &arr {
        println!("{} ", x);
    }
}

//动态数组 Vec:动态数组是一种基于堆内存申请的连续动态数据类型，拥有 O(1) 时间复杂度的索引、压入（push）、弹出（pop)。

#[test]
pub fn vec_demo() {
    //创建空Vec
    let v: Vec<i32> = Vec::new();
    println!("{:?}", v);
    //使用宏创建空Vec
    let v: Vec<i32> = vec![];
    //创建包含5个元素的Vec
    let v = vec![1, 2, 3, 4, 5];
    //创建十个零
    let v = vec![0; 10];
    //创建可变的Vec，并压入元素3
    let mut v = vec![1, 2];
    v.push(3);
    //创建拥有两个元素的Vec，并弹出一个元素
    let mut v = vec![1, 2];
    let two = v.pop();
    println!("{}", two.unwrap()); //2
    println!("{:?}", v); //[1]
                         //创建包含三个元素的可变Vec，并索引一个值和修改一个值
    let mut v = vec![1, 2, 3];
    let three = v[2];
    v[1] = v[1] + 5;
}

/**
 * 数组作为参数 可变借用
 */
fn change_arr(arr: &mut [i32; 4]) {
    arr[1] = 2;
    arr[2] = 3;
    arr[3] = 4;
}
/**
 * 数组作为参数 值传递
 */
fn change_arr2(mut arr: [i32; 4]) {
    arr[1] = 2;
    arr[2] = 3;
    arr[3] = 4;
    println!("{:?}", arr);
}

//数组，引用传递
#[test]
pub fn test_arr_param() {
    let mut arr: [i32; 4] = [0_i32; 4];
    change_arr(&mut arr);
    println!("{:?}", arr);
    arr[1] = 1000;
    println!("{:?}", arr);
}
//数组，值传递
#[test]
pub fn test_arr_param2() {
    let mut arr: [i32; 4] = [0_i32; 4];
    change_arr2(arr); //值传递，
    println!("{:?}", arr); //还是0，0,0,0
    arr[1] = 1000;
    println!("{:?}", arr);
}
//切片
#[test]
pub fn arr_slice(){
    let mut data=[10,20,30,40,50];
    use_slice(&mut data[1..4]);
    //passes references of 
    println!("{:?}", data); //[10, 10000, 30, 40, 50]
}

pub fn use_slice(slice: &mut [i32]) {
    slice[0] = 10000;
}

#[test]
pub fn vec_demo2() {
    //创建空集合
    //let v: Vec<i32> = Vec::new();

    let mut v = vec![1, 2, 3]; //使用宏创建
    v.push(4);

    //通过索引获取，越界会导致程序panic
    let third: i32 = v[2];
    let second: &i32 = &(v[1]); //使用引用
    println!("third: {}", third);
    println!("second: {}", second);

    //通过get获取,越界不会panic
    match v.get(8) {
        Some(value) => {
            println!("{}", value);
        }
        None => {
            println!("获取失败")
        }
    }
    //每个值都加50
    for i in &mut v {
        *i += 50;
    }
    //遍历
    for num in &v {
        println!("{}", num);
    }
    v.push(3);
    println!("{:?}", v);
}
